package com.dragon.modules.yuegou.query.product;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.product.ActivityEntity;
import com.dragon.modules.yuegou.enums.product.ActivityActivityStatus;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.time.LocalDate;
import java.time.LocalDateTime;

/**
 * 商品活动 动态查询条件
 * 
 * @author pbuilder generated
 * @date 2023-09-11 19:16:42
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class ActivityQuery extends ActivityEntity implements Query<ActivityEntity> {

	private static final long serialVersionUID = 1L;


    /** 查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

    /** 商圈id查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

    /** 活动编码查询条件 */
	@JsonUnwrapped(prefix = "activityNo")
	private Condition<String> activityNoCondition;

    /** 活动名称查询条件 */
	@JsonUnwrapped(prefix = "activityName")
	private Condition<String> activityNameCondition;

    /** [枚举]活动状态：0-下架-OFFLINE、1-上架-ONLINE、9-草稿-DRAFT查询条件 */
	@JsonUnwrapped(prefix = "activityStatus")
	private Condition<ActivityActivityStatus> activityStatusCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "activityMasterImg")
	private Condition<String> activityMasterImgCondition;

    /** 活动结束日期查询条件 */
	@JsonUnwrapped(prefix = "activityBeginDate")
	private Condition<LocalDate> activityBeginDateCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "activityEntDate")
	private Condition<LocalDate> activityEntDateCondition;

    /** 活动开始时间 时分秒查询条件 */
	@JsonUnwrapped(prefix = "activityBeginTime")
	private Condition<String> activityBeginTimeCondition;

    /** 活动结束日期 时分秒查询条件 */
	@JsonUnwrapped(prefix = "activityEndTime")
	private Condition<String> activityEndTimeCondition;

    /** 活动展示时间查询条件 */
	@JsonUnwrapped(prefix = "activityShowBeginTime")
	private Condition<LocalDateTime> activityShowBeginTimeCondition;

    /** 活动展示结束时间查询条件 */
	@JsonUnwrapped(prefix = "activityShowEndTime")
	private Condition<LocalDateTime> activityShowEndTimeCondition;

    /** 活动地址查询条件 */
	@JsonUnwrapped(prefix = "activityAddress")
	private Condition<String> activityAddressCondition;

    /** 活动价格，这里存文本直接显示，不做出来查询条件 */
	@JsonUnwrapped(prefix = "activityPrice")
	private Condition<String> activityPriceCondition;

    /** 创建人ID查询条件 */
	@JsonUnwrapped(prefix = "createdBy")
	private Condition<String> createdByCondition;

    /** 创建时间查询条件 */
	@JsonUnwrapped(prefix = "createdTime")
	private Condition<LocalDateTime> createdTimeCondition;

    /** 更新人ID查询条件 */
	@JsonUnwrapped(prefix = "modifiedBy")
	private Condition<String> modifiedByCondition;

    /** 更新时间查询条件 */
	@JsonUnwrapped(prefix = "modifiedTime")
	private Condition<LocalDateTime> modifiedTimeCondition;

    /** 逻辑删除，1表示已删除,0表示未删除查询条件 */
	@JsonUnwrapped(prefix = "del")
	private Condition<Boolean> delCondition;

    /** 删除人ID查询条件 */
	@JsonUnwrapped(prefix = "delBy")
	private Condition<String> delByCondition;

    /** 删除时间查询条件 */
	@JsonUnwrapped(prefix = "delTime")
	private Condition<LocalDateTime> delTimeCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public ActivityQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 * 
	 * @param entity 实体对象
	 */
	public ActivityQuery(ActivityEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 * 
	 * @param other 查询条件对象
	 */
	public ActivityQuery(ActivityQuery other) {
		super(other);
		if (other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if (other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		if (other.activityNoCondition != null) {
			this.activityNoCondition = other.activityNoCondition.copy();
		}
		if (other.activityNameCondition != null) {
			this.activityNameCondition = other.activityNameCondition.copy();
		}
		if (other.activityStatusCondition != null) {
			this.activityStatusCondition = other.activityStatusCondition.copy();
		}
		if (other.activityMasterImgCondition != null) {
			this.activityMasterImgCondition = other.activityMasterImgCondition.copy();
		}
		if (other.activityBeginDateCondition != null) {
			this.activityBeginDateCondition = other.activityBeginDateCondition.copy();
		}
		if (other.activityEntDateCondition != null) {
			this.activityEntDateCondition = other.activityEntDateCondition.copy();
		}
		if (other.activityBeginTimeCondition != null) {
			this.activityBeginTimeCondition = other.activityBeginTimeCondition.copy();
		}
		if (other.activityEndTimeCondition != null) {
			this.activityEndTimeCondition = other.activityEndTimeCondition.copy();
		}
		if (other.activityShowBeginTimeCondition != null) {
			this.activityShowBeginTimeCondition = other.activityShowBeginTimeCondition.copy();
		}
		if (other.activityShowEndTimeCondition != null) {
			this.activityShowEndTimeCondition = other.activityShowEndTimeCondition.copy();
		}
		if (other.activityAddressCondition != null) {
			this.activityAddressCondition = other.activityAddressCondition.copy();
		}
		if (other.activityPriceCondition != null) {
			this.activityPriceCondition = other.activityPriceCondition.copy();
		}
		this.setOther(other);
	}
	private void setOther(ActivityQuery other){
		if(other.createdByCondition != null) {
			this.createdByCondition = other.createdByCondition.copy();
		}
		if(other.createdTimeCondition != null) {
			this.createdTimeCondition = other.createdTimeCondition.copy();
		}
		if(other.modifiedByCondition != null) {
			this.modifiedByCondition = other.modifiedByCondition.copy();
		}
		if(other.modifiedTimeCondition != null) {
			this.modifiedTimeCondition = other.modifiedTimeCondition.copy();
		}
		if(other.delCondition != null) {
			this.delCondition = other.delCondition.copy();
		}
		if(other.delByCondition != null) {
			this.delByCondition = other.delByCondition.copy();
		}
		if(other.delTimeCondition != null) {
			this.delTimeCondition = other.delTimeCondition.copy();
		}
	}

	@Override
	public QueryWrapper<ActivityEntity> toQueryWrapper() {
		QueryWrapper<ActivityEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		if (activityNoCondition != null) {
			activityNoCondition.toWrapper(wrapper, COL_ACTIVITY_NO);
		}
		if (activityNameCondition != null) {
			activityNameCondition.toWrapper(wrapper, COL_ACTIVITY_NAME);
		}
		if (activityStatusCondition != null) {
			activityStatusCondition.toWrapper(wrapper, COL_ACTIVITY_STATUS);
		}
		if (activityMasterImgCondition != null) {
			activityMasterImgCondition.toWrapper(wrapper, COL_ACTIVITY_MASTER_IMG);
		}
		if (activityBeginDateCondition != null) {
			activityBeginDateCondition.toWrapper(wrapper, COL_ACTIVITY_BEGIN_DATE);
		}
		if (activityEntDateCondition != null) {
			activityEntDateCondition.toWrapper(wrapper, COL_ACTIVITY_ENT_DATE);
		}
		if (activityBeginTimeCondition != null) {
			activityBeginTimeCondition.toWrapper(wrapper, COL_ACTIVITY_BEGIN_TIME);
		}
		if (activityEndTimeCondition != null) {
			activityEndTimeCondition.toWrapper(wrapper, COL_ACTIVITY_END_TIME);
		}
		if (activityShowBeginTimeCondition != null) {
			activityShowBeginTimeCondition.toWrapper(wrapper, COL_ACTIVITY_SHOW_BEGIN_TIME);
		}
		if (activityShowEndTimeCondition != null) {
			activityShowEndTimeCondition.toWrapper(wrapper, COL_ACTIVITY_SHOW_END_TIME);
		}
		if (activityAddressCondition != null) {
			activityAddressCondition.toWrapper(wrapper, COL_ACTIVITY_ADDRESS);
		}
		if (activityPriceCondition != null) {
			activityPriceCondition.toWrapper(wrapper, COL_ACTIVITY_PRICE);
		}
		return getQueryWrapper(wrapper);
	}
	private QueryWrapper<ActivityEntity> getQueryWrapper(QueryWrapper<ActivityEntity> wrapper){
		if (createdByCondition != null) {
			createdByCondition.toWrapper(wrapper, COL_CREATED_BY);
		}
		if (createdTimeCondition != null) {
			createdTimeCondition.toWrapper(wrapper, COL_CREATED_TIME);
		}
		if (modifiedByCondition != null) {
			modifiedByCondition.toWrapper(wrapper, COL_MODIFIED_BY);
		}
		if (modifiedTimeCondition != null) {
			modifiedTimeCondition.toWrapper(wrapper, COL_MODIFIED_TIME);
		}
		if (delCondition != null) {
			delCondition.toWrapper(wrapper, COL_DEL);
		}
		if (delByCondition != null) {
			delByCondition.toWrapper(wrapper, COL_DEL_BY);
		}
		if (delTimeCondition != null) {
			delTimeCondition.toWrapper(wrapper, COL_DEL_TIME);
		}
		return wrapper;
	}

	
	/**
	 * 构造并返回查询条件
	 * 
	 * @return idCondition 查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return idCondition 查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param idCondition 查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回商圈id查询条件
	 * 
	 * @return busdIdCondition 商圈id查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}
	
	/**
	 * 获取商圈id查询条件
	 * 
	 * @return busdIdCondition 商圈id查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈id查询条件
	 * 
	 * @param busdIdCondition 商圈id查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回活动编码查询条件
	 * 
	 * @return activityNoCondition 活动编码查询条件
	 */
	public Condition<String> activityNo() {
		this.activityNoCondition = new Condition<>();
		return this.activityNoCondition;
	}
	
	/**
	 * 获取活动编码查询条件
	 * 
	 * @return activityNoCondition 活动编码查询条件
	 */
	public Condition<String> getActivityNoCondition() {
		return activityNoCondition;
	}

	/**
	 * 设置活动编码查询条件
	 * 
	 * @param activityNoCondition 活动编码查询条件
	 */
	public void setActivityNoCondition(Condition<String> activityNoCondition) {
		this.activityNoCondition = activityNoCondition;
	}

	/**
	 * 构造并返回活动名称查询条件
	 * 
	 * @return activityNameCondition 活动名称查询条件
	 */
	public Condition<String> activityName() {
		this.activityNameCondition = new Condition<>();
		return this.activityNameCondition;
	}
	
	/**
	 * 获取活动名称查询条件
	 * 
	 * @return activityNameCondition 活动名称查询条件
	 */
	public Condition<String> getActivityNameCondition() {
		return activityNameCondition;
	}

	/**
	 * 设置活动名称查询条件
	 * 
	 * @param activityNameCondition 活动名称查询条件
	 */
	public void setActivityNameCondition(Condition<String> activityNameCondition) {
		this.activityNameCondition = activityNameCondition;
	}

	/**
	 * 构造并返回[枚举]活动状态：0-下架-OFFLINE、1-上架-ONLINE、9-草稿-DRAFT查询条件
	 * 
	 * @return activityStatusCondition [枚举]活动状态：0-下架-OFFLINE、1-上架-ONLINE、9-草稿-DRAFT查询条件
	 */
	public Condition<ActivityActivityStatus> activityStatus() {
		this.activityStatusCondition = new Condition<>();
		return this.activityStatusCondition;
	}
	
	/**
	 * 获取[枚举]活动状态：0-下架-OFFLINE、1-上架-ONLINE、9-草稿-DRAFT查询条件
	 * 
	 * @return activityStatusCondition [枚举]活动状态：0-下架-OFFLINE、1-上架-ONLINE、9-草稿-DRAFT查询条件
	 */
	public Condition<ActivityActivityStatus> getActivityStatusCondition() {
		return activityStatusCondition;
	}

	/**
	 * 设置[枚举]活动状态：0-下架-OFFLINE、1-上架-ONLINE、9-草稿-DRAFT查询条件
	 * 
	 * @param activityStatusCondition [枚举]活动状态：0-下架-OFFLINE、1-上架-ONLINE、9-草稿-DRAFT查询条件
	 */
	public void setActivityStatusCondition(Condition<ActivityActivityStatus> activityStatusCondition) {
		this.activityStatusCondition = activityStatusCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return activityMasterImgCondition 查询条件
	 */
	public Condition<String> activityMasterImg() {
		this.activityMasterImgCondition = new Condition<>();
		return this.activityMasterImgCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return activityMasterImgCondition 查询条件
	 */
	public Condition<String> getActivityMasterImgCondition() {
		return activityMasterImgCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param activityMasterImgCondition 查询条件
	 */
	public void setActivityMasterImgCondition(Condition<String> activityMasterImgCondition) {
		this.activityMasterImgCondition = activityMasterImgCondition;
	}

	/**
	 * 构造并返回活动结束日期查询条件
	 * 
	 * @return activityBeginDateCondition 活动结束日期查询条件
	 */
	public Condition<LocalDate> activityBeginDate() {
		this.activityBeginDateCondition = new Condition<>();
		return this.activityBeginDateCondition;
	}
	
	/**
	 * 获取活动结束日期查询条件
	 * 
	 * @return activityBeginDateCondition 活动结束日期查询条件
	 */
	public Condition<LocalDate> getActivityBeginDateCondition() {
		return activityBeginDateCondition;
	}

	/**
	 * 设置活动结束日期查询条件
	 * 
	 * @param activityBeginDateCondition 活动结束日期查询条件
	 */
	public void setActivityBeginDateCondition(Condition<LocalDate> activityBeginDateCondition) {
		this.activityBeginDateCondition = activityBeginDateCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return activityEntDateCondition 查询条件
	 */
	public Condition<LocalDate> activityEntDate() {
		this.activityEntDateCondition = new Condition<>();
		return this.activityEntDateCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return activityEntDateCondition 查询条件
	 */
	public Condition<LocalDate> getActivityEntDateCondition() {
		return activityEntDateCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param activityEntDateCondition 查询条件
	 */
	public void setActivityEntDateCondition(Condition<LocalDate> activityEntDateCondition) {
		this.activityEntDateCondition = activityEntDateCondition;
	}

	/**
	 * 构造并返回活动开始时间 时分秒查询条件
	 * 
	 * @return activityBeginTimeCondition 活动开始时间 时分秒查询条件
	 */
	public Condition<String> activityBeginTime() {
		this.activityBeginTimeCondition = new Condition<>();
		return this.activityBeginTimeCondition;
	}
	
	/**
	 * 获取活动开始时间 时分秒查询条件
	 * 
	 * @return activityBeginTimeCondition 活动开始时间 时分秒查询条件
	 */
	public Condition<String> getActivityBeginTimeCondition() {
		return activityBeginTimeCondition;
	}

	/**
	 * 设置活动开始时间 时分秒查询条件
	 * 
	 * @param activityBeginTimeCondition 活动开始时间 时分秒查询条件
	 */
	public void setActivityBeginTimeCondition(Condition<String> activityBeginTimeCondition) {
		this.activityBeginTimeCondition = activityBeginTimeCondition;
	}

	/**
	 * 构造并返回活动结束日期 时分秒查询条件
	 * 
	 * @return activityEndTimeCondition 活动结束日期 时分秒查询条件
	 */
	public Condition<String> activityEndTime() {
		this.activityEndTimeCondition = new Condition<>();
		return this.activityEndTimeCondition;
	}
	
	/**
	 * 获取活动结束日期 时分秒查询条件
	 * 
	 * @return activityEndTimeCondition 活动结束日期 时分秒查询条件
	 */
	public Condition<String> getActivityEndTimeCondition() {
		return activityEndTimeCondition;
	}

	/**
	 * 设置活动结束日期 时分秒查询条件
	 * 
	 * @param activityEndTimeCondition 活动结束日期 时分秒查询条件
	 */
	public void setActivityEndTimeCondition(Condition<String> activityEndTimeCondition) {
		this.activityEndTimeCondition = activityEndTimeCondition;
	}

	/**
	 * 构造并返回活动展示时间查询条件
	 * 
	 * @return activityShowBeginTimeCondition 活动展示时间查询条件
	 */
	public Condition<LocalDateTime> activityShowBeginTime() {
		this.activityShowBeginTimeCondition = new Condition<>();
		return this.activityShowBeginTimeCondition;
	}
	
	/**
	 * 获取活动展示时间查询条件
	 * 
	 * @return activityShowBeginTimeCondition 活动展示时间查询条件
	 */
	public Condition<LocalDateTime> getActivityShowBeginTimeCondition() {
		return activityShowBeginTimeCondition;
	}

	/**
	 * 设置活动展示时间查询条件
	 * 
	 * @param activityShowBeginTimeCondition 活动展示时间查询条件
	 */
	public void setActivityShowBeginTimeCondition(Condition<LocalDateTime> activityShowBeginTimeCondition) {
		this.activityShowBeginTimeCondition = activityShowBeginTimeCondition;
	}

	/**
	 * 构造并返回活动展示结束时间查询条件
	 * 
	 * @return activityShowEndTimeCondition 活动展示结束时间查询条件
	 */
	public Condition<LocalDateTime> activityShowEndTime() {
		this.activityShowEndTimeCondition = new Condition<>();
		return this.activityShowEndTimeCondition;
	}
	
	/**
	 * 获取活动展示结束时间查询条件
	 * 
	 * @return activityShowEndTimeCondition 活动展示结束时间查询条件
	 */
	public Condition<LocalDateTime> getActivityShowEndTimeCondition() {
		return activityShowEndTimeCondition;
	}

	/**
	 * 设置活动展示结束时间查询条件
	 * 
	 * @param activityShowEndTimeCondition 活动展示结束时间查询条件
	 */
	public void setActivityShowEndTimeCondition(Condition<LocalDateTime> activityShowEndTimeCondition) {
		this.activityShowEndTimeCondition = activityShowEndTimeCondition;
	}

	/**
	 * 构造并返回活动地址查询条件
	 * 
	 * @return activityAddressCondition 活动地址查询条件
	 */
	public Condition<String> activityAddress() {
		this.activityAddressCondition = new Condition<>();
		return this.activityAddressCondition;
	}
	
	/**
	 * 获取活动地址查询条件
	 * 
	 * @return activityAddressCondition 活动地址查询条件
	 */
	public Condition<String> getActivityAddressCondition() {
		return activityAddressCondition;
	}

	/**
	 * 设置活动地址查询条件
	 * 
	 * @param activityAddressCondition 活动地址查询条件
	 */
	public void setActivityAddressCondition(Condition<String> activityAddressCondition) {
		this.activityAddressCondition = activityAddressCondition;
	}

	/**
	 * 构造并返回活动价格，这里存文本直接显示，不做出来查询条件
	 * 
	 * @return activityPriceCondition 活动价格，这里存文本直接显示，不做出来查询条件
	 */
	public Condition<String> activityPrice() {
		this.activityPriceCondition = new Condition<>();
		return this.activityPriceCondition;
	}
	
	/**
	 * 获取活动价格，这里存文本直接显示，不做出来查询条件
	 * 
	 * @return activityPriceCondition 活动价格，这里存文本直接显示，不做出来查询条件
	 */
	public Condition<String> getActivityPriceCondition() {
		return activityPriceCondition;
	}

	/**
	 * 设置活动价格，这里存文本直接显示，不做出来查询条件
	 * 
	 * @param activityPriceCondition 活动价格，这里存文本直接显示，不做出来查询条件
	 */
	public void setActivityPriceCondition(Condition<String> activityPriceCondition) {
		this.activityPriceCondition = activityPriceCondition;
	}

	/**
	 * 构造并返回创建人ID查询条件
	 * 
	 * @return createdByCondition 创建人ID查询条件
	 */
	public Condition<String> createdBy() {
		this.createdByCondition = new Condition<>();
		return this.createdByCondition;
	}
	
	/**
	 * 获取创建人ID查询条件
	 * 
	 * @return createdByCondition 创建人ID查询条件
	 */
	public Condition<String> getCreatedByCondition() {
		return createdByCondition;
	}

	/**
	 * 设置创建人ID查询条件
	 * 
	 * @param createdByCondition 创建人ID查询条件
	 */
	public void setCreatedByCondition(Condition<String> createdByCondition) {
		this.createdByCondition = createdByCondition;
	}

	/**
	 * 构造并返回创建时间查询条件
	 * 
	 * @return createdTimeCondition 创建时间查询条件
	 */
	public Condition<LocalDateTime> createdTime() {
		this.createdTimeCondition = new Condition<>();
		return this.createdTimeCondition;
	}
	
	/**
	 * 获取创建时间查询条件
	 * 
	 * @return createdTimeCondition 创建时间查询条件
	 */
	public Condition<LocalDateTime> getCreatedTimeCondition() {
		return createdTimeCondition;
	}

	/**
	 * 设置创建时间查询条件
	 * 
	 * @param createdTimeCondition 创建时间查询条件
	 */
	public void setCreatedTimeCondition(Condition<LocalDateTime> createdTimeCondition) {
		this.createdTimeCondition = createdTimeCondition;
	}

	/**
	 * 构造并返回更新人ID查询条件
	 * 
	 * @return modifiedByCondition 更新人ID查询条件
	 */
	public Condition<String> modifiedBy() {
		this.modifiedByCondition = new Condition<>();
		return this.modifiedByCondition;
	}
	
	/**
	 * 获取更新人ID查询条件
	 * 
	 * @return modifiedByCondition 更新人ID查询条件
	 */
	public Condition<String> getModifiedByCondition() {
		return modifiedByCondition;
	}

	/**
	 * 设置更新人ID查询条件
	 * 
	 * @param modifiedByCondition 更新人ID查询条件
	 */
	public void setModifiedByCondition(Condition<String> modifiedByCondition) {
		this.modifiedByCondition = modifiedByCondition;
	}

	/**
	 * 构造并返回更新时间查询条件
	 * 
	 * @return modifiedTimeCondition 更新时间查询条件
	 */
	public Condition<LocalDateTime> modifiedTime() {
		this.modifiedTimeCondition = new Condition<>();
		return this.modifiedTimeCondition;
	}
	
	/**
	 * 获取更新时间查询条件
	 * 
	 * @return modifiedTimeCondition 更新时间查询条件
	 */
	public Condition<LocalDateTime> getModifiedTimeCondition() {
		return modifiedTimeCondition;
	}

	/**
	 * 设置更新时间查询条件
	 * 
	 * @param modifiedTimeCondition 更新时间查询条件
	 */
	public void setModifiedTimeCondition(Condition<LocalDateTime> modifiedTimeCondition) {
		this.modifiedTimeCondition = modifiedTimeCondition;
	}

	/**
	 * 构造并返回逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @return delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public Condition<Boolean> del() {
		this.delCondition = new Condition<>();
		return this.delCondition;
	}
	
	/**
	 * 获取逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @return delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public Condition<Boolean> getDelCondition() {
		return delCondition;
	}

	/**
	 * 设置逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @param delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public void setDelCondition(Condition<Boolean> delCondition) {
		this.delCondition = delCondition;
	}

	/**
	 * 构造并返回删除人ID查询条件
	 * 
	 * @return delByCondition 删除人ID查询条件
	 */
	public Condition<String> delBy() {
		this.delByCondition = new Condition<>();
		return this.delByCondition;
	}
	
	/**
	 * 获取删除人ID查询条件
	 * 
	 * @return delByCondition 删除人ID查询条件
	 */
	public Condition<String> getDelByCondition() {
		return delByCondition;
	}

	/**
	 * 设置删除人ID查询条件
	 * 
	 * @param delByCondition 删除人ID查询条件
	 */
	public void setDelByCondition(Condition<String> delByCondition) {
		this.delByCondition = delByCondition;
	}

	/**
	 * 构造并返回删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> delTime() {
		this.delTimeCondition = new Condition<>();
		return this.delTimeCondition;
	}
	
	/**
	 * 获取删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> getDelTimeCondition() {
		return delTimeCondition;
	}

	/**
	 * 设置删除时间查询条件
	 * 
	 * @param delTimeCondition 删除时间查询条件
	 */
	public void setDelTimeCondition(Condition<LocalDateTime> delTimeCondition) {
		this.delTimeCondition = delTimeCondition;
	}

}
